//Copyright (c) 2010, Information Security Institute of Wuhan Universtiy(ISIWhu)
//All rights reserved.
//
//PLEASE READ THIS DOCUMENT CAREFULLY BEFORE UTILIZING THE PROGRAM
//BY UTILIZING THIS PROGRAM, YOU AGREE TO BECOME BOUND BY THE TERMS OF
//THIS LICENSE.  IF YOU DO NOT AGREE TO THE TERMS OF THIS LICENSE, DO
//NOT USE THIS PROGRAM OR ANY PORTION THEREOF IN ANY FORM OR MANNER.
//
//This License allows you to:
//1. Make copies and distribute copies of the Program's source code provide that any such copy 
//   clearly displays any and all appropriate copyright notices and disclaimer of warranty as set 
//   forth in this License.
//2. Modify the original copy or copies of the Program or any portion thereof ("Modification(s)"). 
//   Modifications may be copied and distributed under the terms and conditions as set forth above. 
//   Any and all modified files must be affixed with prominent notices that you have changed the 
//   files and the date that the changes occurred.

//Termination:
//   If at anytime you are unable to comply with any portion of this License you must immediately 
//   cease use of the Program and all distribution activities involving the Program or any portion 
//   thereof.

//Statement:
//   In this program, part of the code is from the GTNetS project, The Georgia Tech Network 
//   Simulator (GTNetS) is a full-featured network simulation environment that allows researchers in 
//   computer networks to study the behavior of moderate to large scale networks, under a variety of 
//   conditions. Our work have great advance due to this project, Thanks to Dr. George F. Riley from 
//   Georgia Tech Research Corporation. Anyone who wants to study the GTNetS can come to its homepage:
//   http://www.ece.gatech.edu/research/labs/MANIACS/GTNetS/
//


//File Information:
//
//
//File Name:
//File Purpose:
//Original Author:
//Author Organization:
//Construct Data:
//Modify Author:
//Author Organization:
//Modify Data:



// Georgia Tech Network Simulator - Timer Class
// George F. Riley.  Georgia Tech, Spring 2002

#include "G_debug.h"
#include "timer.h"
#include "simulator.h"

using namespace std;

// Provide a constructor
Timer::Timer()
{
}

void Timer::Handle(Event* e, Time_t t)
{
  TimerEvent* ev = (TimerEvent*)e;
  if (!ev->timerHandler)
    {
      cout << "HuH?  Timer::Handle with no timerHandler" << endl;
      delete e;
      return;
    }
  if (ev->cancelled)
    {
      cout << "HuH?  Handling cancelled timer " << ev 
           << " handler " << ev->timerHandler << endl;
    }
  ev->timerHandler->Timeout(ev);
}

void Timer::Timeout(TimerEvent* ev)
{ // Override if needed
  cout << "default timeout handler " << endl;
  delete ev;
}

void Timer::Schedule(TimerEvent* ev, Time_t when, TimerHandler* h )
{
  // Set the specified timeout handler
  ev->timerHandler = h;
  ev->timer = this;
  // Schedule the event "when" in the future
  DEBUG0((cout << "Scheduling timeout event at time " << when << endl));
  Scheduler::Schedule(ev, when, this);
  ev->cancelled = false;
}

void Timer::Schedule(TimerEvent* ev, Time_t when )
{
  Schedule(ev, when, this); // Use self as the handler for this event
}

void Timer::Cancel(TimerEvent* ev)
{ // Cancelling DOES NOT delete the event (can be re-used)
  Scheduler::Cancel(ev);
  ev->cancelled = true;
}

void Timer::Pause(TimerEvent* ev)
{
  ev->remainingTime = ev->Time() - Simulator::instance->Now();
  // remove the timeout event from the queue
  Cancel(ev);
}

void Timer::Resume(TimerEvent* ev)
{
  ev->cancelled = false;
  Scheduler::Schedule(ev, ev->remainingTime, this);
}

void Timer::ResumeAfter(TimerEvent* ev, Time_t time)
{
  ev->cancelled = false;
  Scheduler::Schedule(ev, ev->remainingTime + time, this);
}

void Timer::Resume(TimerEvent* ev, TimerHandler* h )
{
  ev->timerHandler=h;
  ev->cancelled = false;
  Scheduler::Schedule(ev, ev->remainingTime, this);
}
